#include "AnalizadorDatos.h"

#include <map>
#include <queue>
#include <list>
#include <vector>
#include <iostream>
#include <utility>
#include <fstream>
#include <cstdlib>
#include <limits.h>

using namespace std;

Nodo::Nodo()
{
    k=0;
    valor_cota=0;
}

Nodo::Nodo(const Nodo& N)
{
    k=N.k;
    valor_cota=N.valor_cota;
    solucion=N.solucion;
}

void Nodo::Muestra()
{
    cout << "k: " << k << "\t Valor cota: " << valor_cota << "\t Valor: " << valor << "\tSolucion: ";
    vector<int>::iterator it=solucion.begin();
    for(int i=0; i<(signed)solucion.size(); i++, it++)
    {
        cout << *it << "\t";
    }
    cout << endl;
}

void Nodo::setValor(int i)
{
    valor=i;
}

bool Nodo::IsIN(int j)
{
    bool encontrado=false;
    vector<int>::iterator it=solucion.begin();
    for(int i=0; i<(signed)solucion.size() && !encontrado; i++, it++)
    {
        if(*it==j)encontrado=true;
    }
    return encontrado;
}

bool Nodo::menor(Nodo n, Nodo m)
{
    return(n.valor_cota<=m.valor_cota);
}

bool Nodo::operator<(const Nodo e)const
{
    return(valor_cota<=e.valor_cota);
}
bool Nodo::operator>(const Nodo e)const
{
    return(valor_cota>e.valor_cota);
}

Nodo Nodo::operator=(const Nodo N)
{
    if(this!=&N)
    {
        k=N.k;
        valor_cota=N.valor_cota;
        solucion=N.solucion;
    }
    return *this;
}

void Nodo::setK(int i)
{
    k=i;
}

void Nodo::setCota(int cota)
{
    valor_cota=cota;
}

void Nodo::setVector(vector<int> vector)
{
    solucion=vector;
}

void Nodo::setNewData(int dato)
{
    solucion.push_back(dato);
}

int Nodo::getCota()
{
    return valor_cota;
}

int Nodo::getK()
{
    return k;
}

vector<int> Nodo::getSolucion()
{
    return solucion;
}



DatosProblema::DatosProblema(string nombreFichero)
{
    nomFich=nombreFichero;
    Analisis();
    Expansion=0;
    Poda=0;
    NNodo=0;
    Usados=0;
}

void DatosProblema::incExpansion()
{
    Expansion++;
}

void DatosProblema::incPoda()
{
    Poda++;
}

void DatosProblema::incNNodo()
{
    NNodo++;
}

void DatosProblema::incUsados()
{
    Usados++;
}

int DatosProblema::getUsados()
{
    return Usados;
}
int DatosProblema::getNNodo()
{
    return NNodo;
}

int DatosProblema::getPoda()
{
    return Poda;
}

int DatosProblema::getExpansion()
{
    return Expansion;
}

void DatosProblema::setCota(int valor)
{
    Cota=valor;
}

int DatosProblema::getCota()
{
    return Cota;
}

int DatosProblema::getModalidad()
{
    return Modalidad;
}

void DatosProblema::Analisis()
{
    ifstream fichero_de_datos;
    fichero_de_datos.open(nomFich.c_str(), ios::in);
    if(!fichero_de_datos.is_open())
    {
        cout << "Fichero no se ha podido abrir" << endl;
        exit(2);
    }

    fichero_de_datos >> Modalidad >> Num_elementos;
    Cota=INT_MAX;
    ValorInicialDeCota=INT_MAX;
    int BaseIndex1=0;
    int BaseIndex2=0;
    int PesoMatrix=0;
    for(int i=0; i<Num_elementos; i++, BaseIndex1++)
    {
        BaseIndex2=0;
        for(int j=0; j<Num_elementos; j++, BaseIndex2++)
        {
            fichero_de_datos >> PesoMatrix;
            RellenarMatrizAdyacencia(BaseIndex1, BaseIndex2, PesoMatrix);
        }
    }
    fichero_de_datos.close();
}

void DatosProblema::RellenarMatrizAdyacencia(int index1, int index2, int value)
{
    adyacencia[pair<int,int>(index1,index2)]=value;
}

int DatosProblema::BuscarValor(int index1,int index2)
{
    int temp = adyacencia[pair<int,int>(index1,index2)];
    return temp;
}

int DatosProblema::getNum_elementos()
{
    return Num_elementos;
}

















